home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / datelib.exe / READTIME.C < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-27  |  11.0 KB  |  292 lines
  1. static char readtime_prog[] = "@(#)char *readtime(int f, char *tstr) - Zeit einlesen";
  2. static char readtime_ver[]  = "@(#)v1.20/kr ; 21.07.91";
  3. /* readtime         Einlesen eines Zeit-String
  4. **
  5. ** Autor            Klaus Rath
  6. **
  7. ** Deklaration      char *readtime(int format, char *timestring);
  8. **
  9. ** Compilation      DOS:  bcc -c readtime.c c:\usr\local\lib\libkrc_s.lib
  10. **                  UNIX: cc  -c readtime.c /u1/usr/lib/libkrc.a
  11. **                  ( unter DOS kann die Funktion im small-Modell laufen )
  12. **
  13. ** Übergabe         Die Funktion erwartet einen Integer, der angibt in wel-
  14. **                  chem Format eingelesen werden soll.
  15. **                  Z.Zt. erlaubte Formate (siehe datum.h) :
  16. **                  hh:mm[:ss] -- Formate 1,2
  17. **                  hh.mm[.ss] -- Formate 3,4
  18. **                  hhmm[ss]   -- Datenbankformate 5,6 (DDB/4)
  19. **                  Außerdem wird ein Zeiger auf ein char-Array zur Aufnahme
  20. **                  des Ergebnisses erwartet.
  21. **
  22. ** Rückgabe         (char *) auf timestring
  23. **
  24. ** Anmerkungen      Die Funktion prüft nicht die Validität der eingegebenen
  25. **                  Zeit - dies sollte die aufrufende Funktion selbst tun,
  26. **                  bzw. den Test durch checktime() durchführen lassen.
  27. **                  Die Funktion benutzt zum Einlesen eine Funktion
  28. **                  int editgetch(int form), die einen Tastendruck entsprechend
  29. **                  dem übergebenen Format form bewertet. Z.Zt. sind folgende
  30. **                  Formate implementiert ( s. util.h ) :
  31. **                  ALL    (1) - Alle Character 0 - 255
  32. **                  UPPER  (2) - Buchstaben werden in GROSS konvertiert
  33. **                  LOWER  (3) - Buchstaben werden in klein konvertiert
  34. **                  NUM    (4) - Zahlen, '.', ',', '+', '-'
  35. **                  DATUM  (5) - Zahlen, '.', '/', '-'
  36. **                  ZEIT   (6) - Zahlen, '.', ':'
  37. **                  readtime() stellt dem Aufrufer eine Maske des angeforder-
  38. **                  ten Format zur Verfügung ( z.B. 00:00:00 ), wobei die
  39. **                  Unterstriche durch Zahlen gefüllt werden müssen. Die
  40. **                  u.U. nötigen Trennzeichen sind im Gegensatz zu den Zahlen
  41. **                  nicht editierbar und werden automatisch erzeugt. Eine
  42. **                  Korrektur der Zahlen ist über die BACKSPACE-Taste möglich.
  43. **                  Die Eingabe von RETURN oder ESCAPE beendet die Eingabe
  44. **                  immer, hinter der letzten Position genügt ein beliebige
  45. **                  Tastendruck dafür - außer BACKSPACE, wg. Korrektur.
  46. **
  47. ** Änderungen       1.00 ; 09.06.91
  48. **                  - Erste Version
  49. **                  1.10 ; 18.07.91
  50. **                  - Fehler im Korrekturteil beseitigt.
  51. **                  - Variable int trenner = ':'||'.' eingefügt.
  52. **                  1.20 ; 21.07.91
  53. **                  - Berücksichtigung eines evtl. bereits eingegebenen
  54. **                    ersten Zeichens (dazu Variable: int def_char).
  55. **                  - Taste ESC (27) gibt jetzt einen NULL-Zeiger zurück
  56. **                    ( tatsächlicher Abbruch !), während RETURN weiterhin
  57. **                    den vorbelegten bzw. (teil-)ausgefüllten String liefert.
  58. */
  59.  
  60. #include <stdio.h>
  61. #include <string.h>
  62. #ifdef __TURBOC__
  63. #define ANSI
  64. #define KR_SYS
  65. #include <stdlib.h>
  66. #include "datum.h"
  67. #include "util.h"
  68. #else
  69. #include "/u1/usr/include/datum.h"
  70. #include "/u1/usr/include/util.h"
  71. #endif
  72.  
  73. #ifdef ANSI
  74. char *readtime(int format, char *tstring)
  75. #else
  76. char *readtime(format,tstring)
  77. int  format;
  78. char *tstring;
  79. #endif
  80. {
  81.     /* Variablendefinitionen :
  82.     */
  83.     int trennpos1 = 2,                       /* Positionen von Trennzeichen */
  84.         trennpos2 = 5;
  85.     int trenner;                             /* Trennzeichen                */
  86.     int pos       = 0;                       /* Aktuelle Position           */
  87.     int maxpos    = 11;                      /* Letztmögliche Position      */
  88.     int max       = 0;                       /* Schalter, ob am Ende        */
  89.     int ch;                                  /* Einzulesendes Zeichen       */
  90.     int def_char  = '0';                     /* Vorbelegungszeichen         */
  91.  
  92.     /* Berücksichtigung eines bereits vorhandenen 1. Zeichens in tstring :
  93.     */
  94.     if ( tstring[0] == '\0' ) {
  95.         tstring[0] = def_char;
  96.     }
  97.     else {
  98.         pos    = 1;
  99.     }
  100.  
  101.     /* Format überprüfen, String vorbelegen, Anzeigemaske erzeugen :
  102.     */
  103.     switch ( format ) {
  104.         case TI_HM_D :
  105.                  trenner            = 58;
  106.                  maxpos             = 6;
  107.                  tstring[1]         = def_char;
  108.                  tstring[trennpos1] = trenner;
  109.                  tstring[3]         = def_char;
  110.                  tstring[4]         = def_char;
  111.                  tstring[5]         = '\0';
  112.                  trennpos2          = 99;
  113.                  printf("%c0:00",tstring[0]);
  114.                  printf("\b\b\b\b");
  115.                  break;
  116.         case TI_HM_P :
  117.                  trenner            = 46;
  118.                  maxpos             = 6;
  119.                  tstring[1]         = def_char;
  120.                  tstring[trennpos1] = trenner;
  121.                  tstring[3]         = def_char;
  122.                  tstring[4]         = def_char;
  123.                  tstring[5]         = '\0';
  124.                  trennpos2          = 99;
  125.                  printf("%c0.00",tstring[0]);
  126.                  printf("\b\b\b\b");
  127.                  break;
  128.         case TI_HMS_P :
  129.                  trenner            = 46;
  130.                  maxpos             = 9;
  131.                  tstring[1]         = def_char;
  132.                  tstring[trennpos1] = trenner;
  133.                  tstring[3]         = def_char;
  134.                  tstring[4]         = def_char;
  135.                  tstring[trennpos2] = trenner;
  136.                  tstring[6]         = def_char;
  137.                  tstring[7]         = def_char;
  138.                  tstring[8]         = '\0';
  139.                  printf("%c0.00.00",tstring[0]);
  140.                  printf("\b\b\b\b\b\b\b");
  141.                  break;
  142.         case TI_HM_DB :
  143.                  maxpos             = 5;
  144.                  tstring[1]         = def_char;
  145.                  tstring[2]         = def_char;
  146.                  tstring[3]         = def_char;
  147.                  tstring[4]         = '\0';
  148.                  trennpos1          =
  149.                  trennpos2          = 99;
  150.                  printf("%c000",tstring[0]);
  151.                  printf("\b\b\b");
  152.                  break;
  153.         case TI_HMS_DB :
  154.                  maxpos             = 7;
  155.                  tstring[1]         = def_char;
  156.                  tstring[2]         = def_char;
  157.                  tstring[3]         = def_char;
  158.                  tstring[4]         = def_char;
  159.                  tstring[5]         = def_char;
  160.                  tstring[6]         = '\0';
  161.                  trennpos1 =
  162.                  trennpos2 = 99;
  163.                  printf("%c00000",tstring[0]);
  164.                  printf("\b\b\b\b\b");
  165.                  break;
  166.         case TI_HMS_D :
  167.         default :
  168.                  trenner            = 58;
  169.                  maxpos             = 9;
  170.                  tstring[1]         = def_char;
  171.                  tstring[trennpos1] = trenner;
  172.                  tstring[3]         = def_char;
  173.                  tstring[4]         = def_char;
  174.                  tstring[trennpos2] = trenner;
  175.                  tstring[6]         = def_char;
  176.                  tstring[7]         = def_char;
  177.                  tstring[8]         = '\0';
  178.                  printf("%c0:00:00",tstring[0]);
  179.                  printf("\b\b\b\b\b\b\b");
  180.                  break;
  181.     } /* ENDE: switch(format) */
  182.  
  183.     /* Evtl. noch ein BACKSPACE ausführen :
  184.     */
  185.     if ( !pos ) {
  186.         printf("\b");
  187.     }
  188.  
  189.     /* Tastendrucke abholen, bis maxpos :
  190.     */
  191.     while ( pos < maxpos + 1 ) {
  192.  
  193.         /* Falls fertig, String zurückgeben :
  194.         */
  195.         if ( pos == maxpos ) {
  196.             tstring[pos] = '\0';
  197.             return(tstring);
  198.         }
  199.         /* An eventuellen Trennerpositionen den passenden Trenner einfügen
  200.         ** und den nächsten Schleifendurchlauf abwarten :
  201.         */
  202.         if ( pos == trennpos1 || pos == trennpos2 ) {
  203.             printf("%c",trenner);
  204.             pos++;
  205.             continue;
  206.         }
  207.         /* An der vorletzten Position sind alle Tasten erlaubt, denn nur
  208.         ** BACKSPACE bleibt in der Funktion :
  209.         */
  210.         if ( pos == maxpos - 1 ) {
  211.             max = 1;
  212.             ch  = editgetch(ALL);
  213.         } /* pos < maxpos -1 */
  214.         else
  215.             ch  = editgetch(ZEIT);
  216.  
  217.         /* Auswertung der gedrückten Taste :
  218.         */
  219.         switch ( ch ) {
  220.  
  221.             /* Nicht Zulässiges ignorieren :
  222.             */
  223.             case NULL:
  224.             case -1  :
  225.                        break;
  226.  
  227.             /* Abbruchmöglichkeiten :
  228.             */
  229.             case 27  :
  230.                        tstring[0] = '\0';
  231.                        return(tstring);
  232.             case 10  :
  233.             case 13  :
  234.                        return(tstring);
  235.  
  236.             /* Korrekturmöglichkeit :
  237.             */
  238.             case  8  :
  239.                        if ( pos == trennpos1 || pos == trennpos2 ) {
  240.                            tstring[pos] = trenner;
  241.                        }
  242.                        else {
  243.                            tstring[pos]      = 48;
  244.                            tstring[maxpos-1] = '\0';
  245.                        }
  246.  
  247.                        /* Schalter für MAX-Position zurücksetzen :
  248.                        */
  249.                        if ( max )
  250.                           max = 0;
  251.  
  252.                        /* Trenner überspringen und Maskendefault anzeigen :
  253.                        */
  254.                        if ( pos == trennpos1 + 1 || pos == trennpos2 + 1 ) {
  255.                           printf("\b\b0\b");
  256.                           pos -= 2;
  257.                           break;
  258.                        }
  259.  
  260.                        /* Ansonsten zurück und Maskendefault anzeigen :
  261.                        */
  262.                        if ( pos ) {
  263.                            printf("\b0\b");
  264.                            pos--;
  265.                        }
  266.                        tstring[pos] = def_char;
  267.  
  268.                        break;
  269.             default  :
  270.                        /* Falls wir fertig sind, String abschließen und
  271.                        ** zurückgeben :
  272.                        */
  273.                        if ( max ) {
  274.                            tstring[pos] = '\0';
  275.                            return(tstring);
  276.                        }
  277.  
  278.                        /* Ansonsten ist es eine Zahl, die angezeigt und ein-
  279.                        ** getragen wird :
  280.                        */
  281.                        printf("%c",ch);
  282.                        tstring[pos] = ch;
  283.                        pos++;
  284.  
  285.         } /* ENDE: switch(ch) */
  286.     } /* ENDE: while(pos) */
  287.  
  288.     return(tstring);
  289.  
  290. } /* ENDE: readtime() */
  291.  
  292.